home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / atlwin.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  30.9 KB  |  1,278 lines
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) 1996-1997 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  10.  
  11. #ifndef __ATLWIN_H__
  12. #define __ATLWIN_H__
  13.  
  14. #ifndef __cplusplus
  15.     #error ATL requires C++ compilation (use a .cpp suffix)
  16. #endif
  17.  
  18. #ifndef __ATLBASE_H__
  19.     #error atlwin.h requires atlbase.h to be included first
  20. #endif
  21.  
  22. #ifndef ATL_NO_NAMESPACE
  23. namespace ATL
  24. {
  25. #endif
  26.  
  27. /////////////////////////////////////////////////////////////////////////////
  28. // Forward declarations
  29.  
  30. class CWindow;
  31. class CMessageMap;
  32. class CDynamicChain;
  33. class CWndClassInfo;
  34. template <class T> class CWindowImpl;
  35. template <class T> class CDialogImpl;
  36. class CContainedWindow;
  37.  
  38. /////////////////////////////////////////////////////////////////////////////
  39. // CWindow - client side for a Windows window
  40.  
  41. class CWindow
  42. {
  43. public:
  44.     HWND m_hWnd;
  45.  
  46.     CWindow(HWND hWnd = NULL)
  47.     {
  48.         m_hWnd = hWnd;
  49.     }
  50.  
  51.     CWindow& operator=(HWND hWnd)
  52.     {
  53.         m_hWnd = hWnd;
  54.         return *this;
  55.     }
  56.  
  57.     void Attach(HWND hWndNew)
  58.     {
  59.         _ASSERTE(::IsWindow(hWndNew));
  60.         m_hWnd = hWndNew;
  61.     }
  62.  
  63.     HWND Detach()
  64.     {
  65.         HWND hWnd = m_hWnd;
  66.         m_hWnd = NULL;
  67.         return hWnd;
  68.     }
  69.  
  70.     BOOL DestroyWindow()
  71.     {
  72.         _ASSERTE(::IsWindow(m_hWnd));
  73.  
  74.         if(!::DestroyWindow(m_hWnd))
  75.             return FALSE;
  76.  
  77.         m_hWnd = NULL;
  78.         return TRUE;
  79.     }
  80.  
  81. // Attributes
  82.  
  83.     operator HWND() const { return m_hWnd; }
  84.  
  85.     DWORD GetStyle() const
  86.     {
  87.         _ASSERTE(::IsWindow(m_hWnd));
  88.         return (DWORD)::GetWindowLong(m_hWnd, GWL_STYLE);
  89.     }
  90.  
  91.     DWORD GetExStyle() const
  92.     {
  93.         _ASSERTE(::IsWindow(m_hWnd));
  94.         return (DWORD)::GetWindowLong(m_hWnd, GWL_EXSTYLE);
  95.     }
  96.  
  97.     BOOL ModifyStyle(DWORD dwRemove, DWORD dwAdd, UINT nFlags = 0);
  98.     BOOL ModifyStyleEx(DWORD dwRemove, DWORD dwAdd, UINT nFlags = 0);
  99.  
  100.     LONG GetWindowLong(int nIndex) const
  101.     {
  102.         _ASSERTE(::IsWindow(m_hWnd));
  103.         return ::GetWindowLong(m_hWnd, nIndex);
  104.     }
  105.  
  106.     LONG SetWindowLong(int nIndex, LONG dwNewLong)
  107.     {
  108.         _ASSERTE(::IsWindow(m_hWnd));
  109.         return ::SetWindowLong(m_hWnd, nIndex, dwNewLong);
  110.     }
  111.  
  112.     WORD GetWindowWord(int nIndex) const
  113.     {
  114.         _ASSERTE(::IsWindow(m_hWnd));
  115.         return ::GetWindowWord(m_hWnd, nIndex);
  116.     }
  117.  
  118.     WORD SetWindowWord(int nIndex, WORD wNewWord)
  119.     {
  120.         _ASSERTE(::IsWindow(m_hWnd));
  121.         return ::SetWindowWord(m_hWnd, nIndex, wNewWord);
  122.     }
  123.  
  124. // Message Functions
  125.  
  126.     LRESULT SendMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
  127.     {
  128.         _ASSERTE(::IsWindow(m_hWnd));
  129.         return ::SendMessage(m_hWnd,message,wParam,lParam);
  130.     }
  131.  
  132.     BOOL PostMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
  133.     {
  134.         _ASSERTE(::IsWindow(m_hWnd));
  135.         return ::PostMessage(m_hWnd,message,wParam,lParam);
  136.     }
  137.  
  138.     BOOL SendNotifyMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
  139.     {
  140.         _ASSERTE(::IsWindow(m_hWnd));
  141.         return ::SendNotifyMessage(m_hWnd, message, wParam, lParam);
  142.     }
  143.  
  144. // Window Text Functions
  145.  
  146.     BOOL SetWindowText(LPCTSTR lpszString)
  147.     {
  148.         _ASSERTE(::IsWindow(m_hWnd));
  149.         return ::SetWindowText(m_hWnd, lpszString);
  150.     }
  151.  
  152.     int GetWindowText(LPTSTR lpszStringBuf, int nMaxCount) const
  153.     {
  154.         _ASSERTE(::IsWindow(m_hWnd));
  155.         return ::GetWindowText(m_hWnd, lpszStringBuf, nMaxCount);
  156.     }
  157.  
  158.     int GetWindowTextLength() const
  159.     {
  160.         _ASSERTE(::IsWindow(m_hWnd));
  161.         return ::GetWindowTextLength(m_hWnd);
  162.     }
  163.  
  164.     BOOL GetWindowText(BSTR& bstrText);
  165.  
  166. // Font Functions
  167.  
  168.     void SetFont(HFONT hFont, BOOL bRedraw = TRUE)
  169.     {
  170.         _ASSERTE(::IsWindow(m_hWnd));
  171.         ::SendMessage(m_hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(bRedraw, 0));
  172.     }
  173.  
  174.     HFONT GetFont() const
  175.     {
  176.         _ASSERTE(::IsWindow(m_hWnd));
  177.         return (HFONT)::SendMessage(m_hWnd, WM_GETFONT, 0, 0);
  178.     }
  179.  
  180. // Menu Functions (non-child windows only)
  181.  
  182.     HMENU GetMenu() const
  183.     {
  184.         _ASSERTE(::IsWindow(m_hWnd));
  185.         return ::GetMenu(m_hWnd);
  186.     }
  187.  
  188.     BOOL SetMenu(HMENU hMenu)
  189.     {
  190.         _ASSERTE(::IsWindow(m_hWnd));
  191.         return ::SetMenu(m_hWnd, hMenu);
  192.     }
  193.  
  194.     BOOL DrawMenuBar()
  195.     {
  196.         _ASSERTE(::IsWindow(m_hWnd));
  197.         return ::DrawMenuBar(m_hWnd);
  198.     }
  199.  
  200.     HMENU GetSystemMenu(BOOL bRevert) const
  201.     {
  202.         _ASSERTE(::IsWindow(m_hWnd));
  203.         return ::GetSystemMenu(m_hWnd, bRevert);
  204.     }
  205.  
  206.     BOOL HiliteMenuItem(HMENU hMenu, UINT uItemHilite, UINT uHilite)
  207.     {
  208.         _ASSERTE(::IsWindow(m_hWnd));
  209.         return ::HiliteMenuItem(m_hWnd, hMenu, uItemHilite, uHilite);
  210.     }
  211.  
  212. // Window Size and Position Functions
  213.  
  214.     BOOL IsIconic() const
  215.     {
  216.         _ASSERTE(::IsWindow(m_hWnd));
  217.         return ::IsIconic(m_hWnd);
  218.     }
  219.  
  220.     BOOL IsZoomed() const
  221.     {
  222.         _ASSERTE(::IsWindow(m_hWnd));
  223.         return ::IsZoomed(m_hWnd);
  224.     }
  225.  
  226.     BOOL MoveWindow(int x, int y, int nWidth, int nHeight, BOOL bRepaint = TRUE)
  227.     {
  228.         _ASSERTE(::IsWindow(m_hWnd));
  229.         return ::MoveWindow(m_hWnd, x, y, nWidth, nHeight, bRepaint);
  230.     }
  231.  
  232.     BOOL MoveWindow(LPCRECT lpRect, BOOL bRepaint = TRUE)
  233.     {
  234.         _ASSERTE(::IsWindow(m_hWnd));
  235.         return ::MoveWindow(m_hWnd, lpRect->left, lpRect->top, lpRect->right - lpRect->left, lpRect->bottom - lpRect->top, bRepaint);
  236.     }
  237.  
  238.     BOOL SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT nFlags)
  239.     {
  240.         _ASSERTE(::IsWindow(m_hWnd));
  241.         return ::SetWindowPos(m_hWnd, hWndInsertAfter, x, y, cx, cy, nFlags);
  242.     }
  243.  
  244.     BOOL SetWindowPos(HWND hWndInsertAfter, LPCRECT lpRect, UINT nFlags)
  245.     {
  246.         _ASSERTE(::IsWindow(m_hWnd));
  247.         return ::SetWindowPos(m_hWnd, hWndInsertAfter, lpRect->left, lpRect->top, lpRect->right - lpRect->left, lpRect->bottom - lpRect->top, nFlags);
  248.     }
  249.  
  250.     UINT ArrangeIconicWindows()
  251.     {
  252.         _ASSERTE(::IsWindow(m_hWnd));
  253.         return ::ArrangeIconicWindows(m_hWnd);
  254.     }
  255.  
  256.     BOOL BringWindowToTop()
  257.     {
  258.         _ASSERTE(::IsWindow(m_hWnd));
  259.         return ::BringWindowToTop(m_hWnd);
  260.     }
  261.  
  262.     BOOL GetWindowRect(LPRECT lpRect) const
  263.     {
  264.         _ASSERTE(::IsWindow(m_hWnd));
  265.         return ::GetWindowRect(m_hWnd, lpRect);
  266.     }
  267.  
  268.     BOOL GetClientRect(LPRECT lpRect) const
  269.     {
  270.         _ASSERTE(::IsWindow(m_hWnd));
  271.         return ::GetClientRect(m_hWnd, lpRect);
  272.     }
  273.  
  274.     BOOL GetWindowPlacement(WINDOWPLACEMENT FAR* lpwndpl) const
  275.     {
  276.         _ASSERTE(::IsWindow(m_hWnd));
  277.         return ::GetWindowPlacement(m_hWnd, lpwndpl);
  278.     }
  279.  
  280.     BOOL SetWindowPlacement(const WINDOWPLACEMENT FAR* lpwndpl)
  281.     {
  282.         _ASSERTE(::IsWindow(m_hWnd));
  283.         return ::SetWindowPlacement(m_hWnd, lpwndpl);
  284.     }
  285.  
  286. // Coordinate Mapping Functions
  287.  
  288.     BOOL ClientToScreen(LPPOINT lpPoint) const
  289.     {
  290.         _ASSERTE(::IsWindow(m_hWnd));
  291.         return ::ClientToScreen(m_hWnd, lpPoint);
  292.     }
  293.  
  294.     BOOL ClientToScreen(LPRECT lpRect) const
  295.     {
  296.         _ASSERTE(::IsWindow(m_hWnd));
  297.         if(!::ClientToScreen(m_hWnd, (LPPOINT)lpRect))
  298.             return FALSE;
  299.         return ::ClientToScreen(m_hWnd, ((LPPOINT)lpRect)+1);
  300.     }
  301.  
  302.     BOOL ScreenToClient(LPPOINT lpPoint) const
  303.     {
  304.         _ASSERTE(::IsWindow(m_hWnd));
  305.         return ::ScreenToClient(m_hWnd, lpPoint);
  306.     }
  307.  
  308.     BOOL ScreenToClient(LPRECT lpRect) const
  309.     {
  310.         _ASSERTE(::IsWindow(m_hWnd));
  311.         if(!::ScreenToClient(m_hWnd, (LPPOINT)lpRect))
  312.             return FALSE;
  313.         return ::ScreenToClient(m_hWnd, ((LPPOINT)lpRect)+1);
  314.     }
  315.  
  316.     int MapWindowPoints(HWND hWndTo, LPPOINT lpPoint, UINT nCount) const
  317.     {
  318.         _ASSERTE(::IsWindow(m_hWnd));
  319.         return ::MapWindowPoints(m_hWnd, hWndTo, lpPoint, nCount);
  320.     }
  321.  
  322.     int MapWindowPoints(HWND hWndTo, LPRECT lpRect) const
  323.     {
  324.         _ASSERTE(::IsWindow(m_hWnd));
  325.         return ::MapWindowPoints(m_hWnd, hWndTo, (LPPOINT)lpRect, 2);
  326.     }
  327.  
  328. // Update and Painting Functions
  329.  
  330.     HDC BeginPaint(LPPAINTSTRUCT lpPaint)
  331.     {
  332.         _ASSERTE(::IsWindow(m_hWnd));
  333.         return ::BeginPaint(m_hWnd, lpPaint);
  334.     }
  335.  
  336.     void EndPaint(LPPAINTSTRUCT lpPaint)
  337.     {
  338.         _ASSERTE(::IsWindow(m_hWnd));
  339.         ::EndPaint(m_hWnd, lpPaint);
  340.     }
  341.  
  342.     HDC GetDC()
  343.     {
  344.         _ASSERTE(::IsWindow(m_hWnd));
  345.         return ::GetDC(m_hWnd);
  346.     }
  347.  
  348.     HDC GetWindowDC()
  349.     {
  350.         _ASSERTE(::IsWindow(m_hWnd));
  351.         return ::GetWindowDC(m_hWnd);
  352.     }
  353.  
  354.     int ReleaseDC(HDC hDC)
  355.     {
  356.         _ASSERTE(::IsWindow(m_hWnd));
  357.         return ::ReleaseDC(m_hWnd, hDC);
  358.     }
  359.  
  360.     void Print(HDC hDC, DWORD dwFlags) const
  361.     {
  362.         _ASSERTE(::IsWindow(m_hWnd));
  363.         ::SendMessage(m_hWnd, WM_PRINT, (WPARAM)hDC, dwFlags);
  364.     }
  365.  
  366.     void PrintClient(HDC hDC, DWORD dwFlags) const
  367.     {
  368.         _ASSERTE(::IsWindow(m_hWnd));
  369.         ::SendMessage(m_hWnd, WM_PRINTCLIENT, (WPARAM)hDC, dwFlags);
  370.     }
  371.  
  372.     BOOL UpdateWindow()
  373.     {
  374.         _ASSERTE(::IsWindow(m_hWnd));
  375.         return ::UpdateWindow(m_hWnd);
  376.     }
  377.  
  378.     void SetRedraw(BOOL bRedraw = TRUE)
  379.     {
  380.         _ASSERTE(::IsWindow(m_hWnd));
  381.         ::SendMessage(m_hWnd, WM_SETREDRAW, (WPARAM)bRedraw, 0);
  382.     }
  383.  
  384.     BOOL GetUpdateRect(LPRECT lpRect, BOOL bErase = FALSE)
  385.     {
  386.         _ASSERTE(::IsWindow(m_hWnd));
  387.         return ::GetUpdateRect(m_hWnd, lpRect, bErase);
  388.     }
  389.  
  390.     int GetUpdateRgn(HRGN hRgn, BOOL bErase = FALSE)
  391.     {
  392.         _ASSERTE(::IsWindow(m_hWnd));
  393.         return ::GetUpdateRgn(m_hWnd, hRgn, bErase);
  394.     }
  395.  
  396.     BOOL Invalidate(BOOL bErase = TRUE)
  397.     {
  398.         _ASSERTE(::IsWindow(m_hWnd));
  399.         return ::InvalidateRect(m_hWnd, NULL, bErase);
  400.     }
  401.  
  402.     BOOL InvalidateRect(LPCRECT lpRect, BOOL bErase = TRUE)
  403.     {
  404.         _ASSERTE(::IsWindow(m_hWnd));
  405.         return ::InvalidateRect(m_hWnd, lpRect, bErase);
  406.     }
  407.  
  408.     void InvalidateRgn(HRGN hRgn, BOOL bErase = TRUE)
  409.     {
  410.         _ASSERTE(::IsWindow(m_hWnd));
  411.         ::InvalidateRgn(m_hWnd, hRgn, bErase);
  412.     }
  413.  
  414.     BOOL ValidateRect(LPCRECT lpRect)
  415.     {
  416.         _ASSERTE(::IsWindow(m_hWnd));
  417.         return ::ValidateRect(m_hWnd, lpRect);
  418.     }
  419.  
  420.     BOOL ValidateRgn(HRGN hRgn)
  421.     {
  422.         _ASSERTE(::IsWindow(m_hWnd));
  423.         return ::ValidateRgn(m_hWnd, hRgn);
  424.     }
  425.  
  426.     BOOL ShowWindow(int nCmdShow)
  427.     {
  428.         _ASSERTE(::IsWindow(m_hWnd));
  429.         return ::ShowWindow(m_hWnd, nCmdShow);
  430.     }
  431.  
  432.     BOOL IsWindowVisible() const
  433.     {
  434.         _ASSERTE(::IsWindow(m_hWnd));
  435.         return ::IsWindowVisible(m_hWnd);
  436.     }
  437.  
  438.     BOOL ShowOwnedPopups(BOOL bShow = TRUE)
  439.     {
  440.         _ASSERTE(::IsWindow(m_hWnd));
  441.         return ::ShowOwnedPopups(m_hWnd, bShow);
  442.     }
  443.  
  444.     HDC GetDCEx(HRGN hRgnClip, DWORD flags)
  445.     {
  446.         _ASSERTE(::IsWindow(m_hWnd));
  447.         return ::GetDCEx(m_hWnd, hRgnClip, flags);
  448.     }
  449.  
  450.     BOOL LockWindowUpdate(BOOL bLock = TRUE)
  451.     {
  452.         _ASSERTE(::IsWindow(m_hWnd));
  453.         return ::LockWindowUpdate(bLock ? m_hWnd : NULL);
  454.     }
  455.  
  456.     BOOL RedrawWindow(LPCRECT lpRectUpdate = NULL, HRGN hRgnUpdate = NULL, UINT flags = RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE)
  457.     {
  458.         _ASSERTE(::IsWindow(m_hWnd));
  459.         return ::RedrawWindow(m_hWnd, lpRectUpdate, hRgnUpdate, flags);
  460.     }
  461.  
  462. // Timer Functions
  463.  
  464.     UINT SetTimer(UINT nIDEvent, UINT nElapse, void (CALLBACK* lpfnTimer)(HWND, UINT, UINT, DWORD))
  465.     {
  466.         _ASSERTE(::IsWindow(m_hWnd));
  467.         return ::SetTimer(m_hWnd, nIDEvent, nElapse, (TIMERPROC)lpfnTimer);
  468.     }
  469.  
  470.     BOOL KillTimer(UINT nIDEvent)
  471.     {
  472.         _ASSERTE(::IsWindow(m_hWnd));
  473.         return ::KillTimer(m_hWnd, nIDEvent);
  474.     }
  475.  
  476. // Window State Functions
  477.  
  478.     BOOL IsWindowEnabled() const
  479.     {
  480.         _ASSERTE(::IsWindow(m_hWnd));
  481.         return ::IsWindowEnabled(m_hWnd);
  482.     }
  483.  
  484.     BOOL EnableWindow(BOOL bEnable = TRUE)
  485.     {
  486.         _ASSERTE(::IsWindow(m_hWnd));
  487.         return ::EnableWindow(m_hWnd, bEnable);
  488.     }
  489.  
  490.     HWND SetActiveWindow()
  491.     {
  492.         _ASSERTE(::IsWindow(m_hWnd));
  493.         return ::SetActiveWindow(m_hWnd);
  494.     }
  495.  
  496.     HWND SetCapture()
  497.     {
  498.         _ASSERTE(::IsWindow(m_hWnd));
  499.         return ::SetCapture(m_hWnd);
  500.     }
  501.  
  502.     HWND SetFocus()
  503.     {
  504.         _ASSERTE(::IsWindow(m_hWnd));
  505.         return ::SetFocus(m_hWnd);
  506.     }
  507.  
  508. // Dialog-Box Item Functions
  509.  
  510.     BOOL CheckDlgButton(int nIDButton, UINT nCheck)
  511.     {
  512.         _ASSERTE(::IsWindow(m_hWnd));
  513.         return ::CheckDlgButton(m_hWnd, nIDButton, nCheck);
  514.     }
  515.  
  516.     BOOL CheckRadioButton(int nIDFirstButton, int nIDLastButton, int nIDCheckButton)
  517.     {
  518.         _ASSERTE(::IsWindow(m_hWnd));
  519.         return ::CheckRadioButton(m_hWnd, nIDFirstButton, nIDLastButton, nIDCheckButton);
  520.     }
  521.  
  522.     int DlgDirList(LPTSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT nFileType)
  523.     {
  524.         _ASSERTE(::IsWindow(m_hWnd));
  525.         return ::DlgDirList(m_hWnd, lpPathSpec, nIDListBox, nIDStaticPath, nFileType);
  526.     }
  527.  
  528.     int DlgDirListComboBox(LPTSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT nFileType)
  529.     {
  530.         _ASSERTE(::IsWindow(m_hWnd));
  531.         return ::DlgDirListComboBox(m_hWnd, lpPathSpec, nIDComboBox, nIDStaticPath, nFileType);
  532.     }
  533.  
  534.     BOOL DlgDirSelect(LPTSTR lpString, int nCount, int nIDListBox)
  535.     {
  536.         _ASSERTE(::IsWindow(m_hWnd));
  537.         return ::DlgDirSelectEx(m_hWnd, lpString, nCount, nIDListBox);
  538.     }
  539.  
  540.     BOOL DlgDirSelectComboBox(LPTSTR lpString, int nCount, int nIDComboBox)
  541.     {
  542.         _ASSERTE(::IsWindow(m_hWnd));
  543.         return ::DlgDirSelectComboBoxEx(m_hWnd, lpString, nCount, nIDComboBox);
  544.     }
  545.  
  546.     UINT GetDlgItemInt(int nID, BOOL* lpTrans = NULL, BOOL bSigned = TRUE) const
  547.     {
  548.         _ASSERTE(::IsWindow(m_hWnd));
  549.         return ::GetDlgItemInt(m_hWnd, nID, lpTrans, bSigned);
  550.     }
  551.  
  552.     UINT GetDlgItemText(int nID, LPTSTR lpStr, int nMaxCount) const
  553.     {
  554.         _ASSERTE(::IsWindow(m_hWnd));
  555.         return ::GetDlgItemText(m_hWnd, nID, lpStr, nMaxCount);
  556.     }
  557.  
  558.     BOOL GetDlgItemText(int nID, BSTR& bstrText) const
  559.     {
  560.         _ASSERTE(::IsWindow(m_hWnd));
  561.  
  562.         HWND hWndCtl = GetDlgItem(nID);
  563.         if(hWndCtl == NULL)
  564.             return FALSE;
  565.  
  566.         return CWindow(hWndCtl).GetWindowText(bstrText);
  567.     }
  568.  
  569.     HWND GetNextDlgGroupItem(HWND hWndCtl, BOOL bPrevious = FALSE) const
  570.     {
  571.         _ASSERTE(::IsWindow(m_hWnd));
  572.         return ::GetNextDlgGroupItem(m_hWnd, hWndCtl, bPrevious);
  573.     }
  574.  
  575.     HWND GetNextDlgTabItem(HWND hWndCtl, BOOL bPrevious = FALSE) const
  576.     {
  577.         _ASSERTE(::IsWindow(m_hWnd));
  578.         return ::GetNextDlgTabItem(m_hWnd, hWndCtl, bPrevious);
  579.     }
  580.  
  581.     UINT IsDlgButtonChecked(int nIDButton) const
  582.     {
  583.         _ASSERTE(::IsWindow(m_hWnd));
  584.         return ::IsDlgButtonChecked(m_hWnd, nIDButton);
  585.     }
  586.  
  587.     LRESULT SendDlgItemMessage(int nID, UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
  588.     {
  589.         _ASSERTE(::IsWindow(m_hWnd));
  590.         return ::SendDlgItemMessage(m_hWnd, nID, message, wParam, lParam);
  591.     }
  592.  
  593.     BOOL SetDlgItemInt(int nID, UINT nValue, BOOL bSigned = TRUE)
  594.     {
  595.         _ASSERTE(::IsWindow(m_hWnd));
  596.         return ::SetDlgItemInt(m_hWnd, nID, nValue, bSigned);
  597.     }
  598.  
  599.     BOOL SetDlgItemText(int nID, LPCTSTR lpszString)
  600.     {
  601.         _ASSERTE(::IsWindow(m_hWnd));
  602.         return ::SetDlgItemText(m_hWnd, nID, lpszString);
  603.     }
  604.  
  605. // Scrolling Functions
  606.  
  607.     int GetScrollPos(int nBar) const
  608.     {
  609.         _ASSERTE(::IsWindow(m_hWnd));
  610.         return ::GetScrollPos(m_hWnd, nBar);
  611.     }
  612.  
  613.     BOOL GetScrollRange(int nBar, LPINT lpMinPos, LPINT lpMaxPos) const
  614.     {
  615.         _ASSERTE(::IsWindow(m_hWnd));
  616.         return ::GetScrollRange(m_hWnd, nBar, lpMinPos, lpMaxPos);
  617.     }
  618.  
  619.     BOOL ScrollWindow(int xAmount, int yAmount, LPCRECT lpRect = NULL, LPCRECT lpClipRect = NULL)
  620.     {
  621.         _ASSERTE(::IsWindow(m_hWnd));
  622.         return ::ScrollWindow(m_hWnd, xAmount, yAmount, lpRect, lpClipRect);
  623.     }
  624.  
  625.     int ScrollWindowEx(int dx, int dy, LPCRECT lpRectScroll, LPCRECT lpRectClip, HRGN hRgnUpdate, LPRECT lpRectUpdate, UINT flags)
  626.     {
  627.         _ASSERTE(::IsWindow(m_hWnd));
  628.         return ::ScrollWindowEx(m_hWnd, dx, dy, lpRectScroll, lpRectClip, hRgnUpdate, lpRectUpdate, flags);
  629.     }
  630.  
  631.     int SetScrollPos(int nBar, int nPos, BOOL bRedraw = TRUE)
  632.     {
  633.         _ASSERTE(::IsWindow(m_hWnd));
  634.         return ::SetScrollPos(m_hWnd, nBar, nPos, bRedraw);
  635.     }
  636.  
  637.     BOOL SetScrollRange(int nBar, int nMinPos, int nMaxPos, BOOL bRedraw = TRUE)
  638.     {
  639.         _ASSERTE(::IsWindow(m_hWnd));
  640.         return ::SetScrollRange(m_hWnd, nBar, nMinPos, nMaxPos, bRedraw);
  641.     }
  642.  
  643.     BOOL ShowScrollBar(UINT nBar, BOOL bShow = TRUE)
  644.     {
  645.         _ASSERTE(::IsWindow(m_hWnd));
  646.         return ::ShowScrollBar(m_hWnd, nBar, bShow);
  647.     }
  648.  
  649.     BOOL EnableScrollBar(UINT uSBFlags, UINT uArrowFlags = ESB_ENABLE_BOTH)
  650.     {
  651.         _ASSERTE(::IsWindow(m_hWnd));
  652.         return ::EnableScrollBar(m_hWnd, uSBFlags, uArrowFlags);
  653.     }
  654.  
  655. // Window Access Functions
  656.  
  657.     HWND ChildWindowFromPoint(POINT point) const
  658.     {
  659.         _ASSERTE(::IsWindow(m_hWnd));
  660.         return ::ChildWindowFromPoint(m_hWnd, point);
  661.     }
  662.  
  663.     HWND ChildWindowFromPointEx(POINT point, UINT uFlags) const
  664.     {
  665.         _ASSERTE(::IsWindow(m_hWnd));
  666.         return ::ChildWindowFromPointEx(m_hWnd, point, uFlags);
  667.     }
  668.  
  669.     HWND GetTopWindow() const
  670.     {
  671.         _ASSERTE(::IsWindow(m_hWnd));
  672.         return ::GetTopWindow(m_hWnd);
  673.     }
  674.  
  675.     HWND GetWindow(UINT nCmd) const
  676.     {
  677.         _ASSERTE(::IsWindow(m_hWnd));
  678.         return ::GetWindow(m_hWnd, nCmd);
  679.     }
  680.  
  681.     HWND GetLastActivePopup() const
  682.     {
  683.         _ASSERTE(::IsWindow(m_hWnd));
  684.         return ::GetLastActivePopup(m_hWnd);
  685.     }
  686.  
  687.     BOOL IsChild(HWND hWnd) const
  688.     {
  689.         _ASSERTE(::IsWindow(m_hWnd));
  690.         return ::IsChild(m_hWnd, hWnd);
  691.     }
  692.  
  693.     HWND GetParent() const
  694.     {
  695.         _ASSERTE(::IsWindow(m_hWnd));
  696.         return ::GetParent(m_hWnd);
  697.     }
  698.  
  699.     HWND SetParent(HWND hWndNewParent)
  700.     {
  701.         _ASSERTE(::IsWindow(m_hWnd));
  702.         return ::SetParent(m_hWnd, hWndNewParent);
  703.     }
  704.  
  705. // Window Tree Access
  706.  
  707.     int GetDlgCtrlID() const
  708.     {
  709.         _ASSERTE(::IsWindow(m_hWnd));
  710.         return ::GetDlgCtrlID(m_hWnd);
  711.     }
  712.  
  713.     int SetDlgCtrlID(int nID)
  714.     {
  715.         _ASSERTE(::IsWindow(m_hWnd));
  716.         return (int)::SetWindowLong(m_hWnd, GWL_ID, nID);
  717.     }
  718.  
  719.     HWND GetDlgItem(int nID) const
  720.     {
  721.         _ASSERTE(::IsWindow(m_hWnd));
  722.         return ::GetDlgItem(m_hWnd, nID);
  723.     }
  724.  
  725.     HWND GetDescendantWindow(int nID) const;
  726.  
  727.     void SendMessageToDescendants(UINT message, WPARAM wParam = 0, LPARAM lParam = 0, BOOL bDeep = TRUE);
  728.  
  729. // Alert Functions
  730.  
  731.     BOOL FlashWindow(BOOL bInvert)
  732.     {
  733.         _ASSERTE(::IsWindow(m_hWnd));
  734.         return ::FlashWindow(m_hWnd, bInvert);
  735.     }
  736.  
  737.     int MessageBox(LPCTSTR lpszText, LPCTSTR lpszCaption = NULL, UINT nType = MB_OK)
  738.     {
  739.         _ASSERTE(::IsWindow(m_hWnd));
  740.         return ::MessageBox(m_hWnd, lpszText, lpszCaption, nType);
  741.     }
  742.  
  743. // Clipboard Functions
  744.  
  745.     BOOL ChangeClipboardChain(HWND hWndNewNext)
  746.     {
  747.         _ASSERTE(::IsWindow(m_hWnd));
  748.         return ::ChangeClipboardChain(m_hWnd, hWndNewNext);
  749.     }
  750.  
  751.     HWND SetClipboardViewer()
  752.     {
  753.         _ASSERTE(::IsWindow(m_hWnd));
  754.         return ::SetClipboardViewer(m_hWnd);
  755.     }
  756.  
  757.     BOOL OpenClipboard()
  758.     {
  759.         _ASSERTE(::IsWindow(m_hWnd));
  760.         return ::OpenClipboard(m_hWnd);
  761.     }
  762.  
  763. // Caret Functions
  764.  
  765.     BOOL CreateCaret(HBITMAP hBitmap)
  766.     {
  767.         _ASSERTE(::IsWindow(m_hWnd));
  768.         return ::CreateCaret(m_hWnd, hBitmap, 0, 0);
  769.     }
  770.  
  771.     BOOL CreateSolidCaret(int nWidth, int nHeight)
  772.     {
  773.         _ASSERTE(::IsWindow(m_hWnd));
  774.         return ::CreateCaret(m_hWnd, (HBITMAP)0, nWidth, nHeight);
  775.     }
  776.  
  777.     BOOL CreateGrayCaret(int nWidth, int nHeight)
  778.     {
  779.         _ASSERTE(::IsWindow(m_hWnd));
  780.         return ::CreateCaret(m_hWnd, (HBITMAP)1, nWidth, nHeight);
  781.     }
  782.  
  783.     BOOL HideCaret()
  784.     {
  785.         _ASSERTE(::IsWindow(m_hWnd));
  786.         return ::HideCaret(m_hWnd);
  787.     }
  788.  
  789.     BOOL ShowCaret()
  790.     {
  791.         _ASSERTE(::IsWindow(m_hWnd));
  792.         return ::ShowCaret(m_hWnd);
  793.     }
  794.  
  795. // Drag-Drop Functions
  796.  
  797.     void DragAcceptFiles(BOOL bAccept = TRUE)
  798.     {
  799.         _ASSERTE(::IsWindow(m_hWnd)); ::DragAcceptFiles(m_hWnd, bAccept);
  800.     }
  801.  
  802. // Icon Functions
  803.  
  804.     HICON SetIcon(HICON hIcon, BOOL bBigIcon = TRUE)
  805.     {
  806.         _ASSERTE(::IsWindow(m_hWnd));
  807.         return (HICON)::SendMessage(m_hWnd, WM_SETICON, bBigIcon, (LPARAM)hIcon);
  808.     }
  809.  
  810.     HICON GetIcon(BOOL bBigIcon = TRUE) const
  811.     {
  812.         _ASSERTE(::IsWindow(m_hWnd));
  813.         return (HICON)::SendMessage(m_hWnd, WM_GETICON, bBigIcon, 0);
  814.     }
  815.  
  816. // Help Functions
  817.  
  818.     BOOL WinHelp(LPCTSTR lpszHelp, UINT nCmd = HELP_CONTEXT, DWORD dwData = 0)
  819.     {
  820.         _ASSERTE(::IsWindow(m_hWnd));
  821.         return ::WinHelp(m_hWnd, lpszHelp, nCmd, dwData);
  822.     }
  823.  
  824.     BOOL SetWindowContextHelpId(DWORD dwContextHelpId)
  825.     {
  826.         _ASSERTE(::IsWindow(m_hWnd));
  827.         return ::SetWindowContextHelpId(m_hWnd, dwContextHelpId);
  828.     }
  829.  
  830.     DWORD GetWindowContextHelpId() const
  831.     {
  832.         _ASSERTE(::IsWindow(m_hWnd));
  833.         return ::GetWindowContextHelpId(m_hWnd);
  834.     }
  835.  
  836. // Hot Key Functions
  837.  
  838.     int SetHotKey(WORD wVirtualKeyCode, WORD wModifiers)
  839.     {
  840.         _ASSERTE(::IsWindow(m_hWnd));
  841.         return (int)::SendMessage(m_hWnd, WM_SETHOTKEY, MAKEWORD(wVirtualKeyCode, wModifiers), 0);
  842.     }
  843.  
  844.     DWORD GetHotKey(WORD& /* wVirtualKeyCode */, WORD& /* wModifiers */) const
  845.     {
  846.         _ASSERTE(::IsWindow(m_hWnd));
  847.         return ::SendMessage(m_hWnd, WM_GETHOTKEY, 0, 0);
  848.     }
  849.  
  850. // Misc. Operations
  851.  
  852.     BOOL CenterWindow(HWND hWndCenter = NULL);
  853.  
  854.     HWND GetTopLevelParent() const;
  855.     HWND GetTopLevelWindow() const;
  856. };
  857.  
  858. /////////////////////////////////////////////////////////////////////////////
  859. // WindowProc thunks
  860.  
  861. #if defined(_M_PPC)
  862. #error PPC not yet implemented
  863. #elif defined (_M_ALPHA)
  864. // For ALPHA we will stick the this pointer into a0, which is where
  865. // the HWND is.  However, we don't actually need the HWND so this is OK.
  866. #pragma pack(push,4)
  867. struct _WndProcThunk //this should come out to 20 bytes
  868. {
  869.     DWORD ldah_at;      //  ldah    at, HIWORD(func)
  870.     DWORD ldah_a0;      //  ldah    a0, HIWORD(this)
  871.     DWORD lda_at;       //  lda     at, LOWORD(func)(at)
  872.     DWORD lda_a0;       //  lda     a0, LOWORD(this)(a0)
  873.     DWORD jmp;          //  jmp     zero,(at),0
  874. };
  875. #pragma pack(pop)
  876. #elif defined (_M_IX86)
  877. #pragma pack(push,1)
  878. struct _WndProcThunk
  879. {
  880.     BYTE    m_mov;          // mov ecx, pThis
  881.     DWORD   m_this;         //
  882.     BYTE    m_jmp;          // jmp WndProc
  883.     DWORD   m_relproc;      // relative jmp
  884. };
  885. #pragma pack(pop)
  886. #else
  887. #error Only PPC, ALPHA, and X86 supported
  888. #endif
  889.  
  890. class CWndProcThunk
  891. {
  892. public:
  893.     union
  894.     {
  895.         _AtlCreateWndData cd;
  896.         _WndProcThunk thunk;
  897.     };
  898.     void Init(WNDPROC proc, void* pThis);
  899. };
  900.  
  901.  
  902. /////////////////////////////////////////////////////////////////////////////
  903. // CMessageMap - abstract class that provides an interface for message maps
  904.  
  905. class ATL_NO_VTABLE CMessageMap
  906. {
  907. public:
  908.     virtual BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
  909.         LRESULT& lResult, DWORD dwMsgMapID) = 0;
  910. };
  911.  
  912.  
  913. /////////////////////////////////////////////////////////////////////////////
  914. // Message map
  915.  
  916. #define BEGIN_MSG_MAP(theClass) \
  917. public: \
  918.     BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lResult, DWORD dwMsgMapID = 0) \
  919.     { \
  920.         BOOL bHandled = TRUE; \
  921.         hWnd; \
  922.         switch(dwMsgMapID) \
  923.         { \
  924.         case 0:
  925.  
  926. #define ALT_MSG_MAP(msgMapID) \
  927.         break; \
  928.         case msgMapID:
  929.  
  930. #define MESSAGE_HANDLER(msg, func) \
  931.     if(uMsg == msg) \
  932.     { \
  933.         bHandled = TRUE; \
  934.         lResult = func(uMsg, wParam, lParam, bHandled); \
  935.         if(bHandled) \
  936.             return TRUE; \
  937.     }
  938.  
  939. #define MESSAGE_RANGE_HANDLER(msgFirst, msgLast, func) \
  940.     if(uMsg >= msgFirst && uMsg <= msgLast) \
  941.     { \
  942.         bHandled = TRUE; \
  943.         lResult = func(uMsg, wParam, lParam, bHandled); \
  944.         if(bHandled) \
  945.             return TRUE; \
  946.     }
  947.  
  948. #define COMMAND_HANDLER(id, code, func) \
  949.     if(uMsg == WM_COMMAND && id == LOWORD(wParam) && code == HIWORD(wParam)) \
  950.     { \
  951.         bHandled = TRUE; \
  952.         lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled); \
  953.         if(bHandled) \
  954.             return TRUE; \
  955.     }
  956.  
  957. #define COMMAND_ID_HANDLER(id, func) \
  958.     if(uMsg == WM_COMMAND && id == LOWORD(wParam)) \
  959.     { \
  960.         bHandled = TRUE; \
  961.         lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled); \
  962.         if(bHandled) \
  963.             return TRUE; \
  964.     }
  965.  
  966. #define COMMAND_CODE_HANDLER(code, func) \
  967.     if(uMsg == WM_COMMAND && code == HIWORD(wParam)) \
  968.     { \
  969.         bHandled = TRUE; \
  970.         lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled); \
  971.         if(bHandled) \
  972.             return TRUE; \
  973.     }
  974.  
  975. #define COMMAND_RANGE_HANDLER(idFirst, idLast, func) \
  976.     if(uMsg == WM_COMMAND && LOWORD(wParam) >= idFirst  && LOWORD(wParam) <= idLast) \
  977.     { \
  978.         bHandled = TRUE; \
  979.         lResult = func(HIWORD(wParam), LOWORD(wParam), (HWND)lParam, bHandled); \
  980.         if(bHandled) \
  981.             return TRUE; \
  982.     }
  983.  
  984. #define NOTIFY_HANDLER(id, cd, func) \
  985.     if(uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom && cd == ((LPNMHDR)lParam)->code) \
  986.     { \
  987.         bHandled = TRUE; \
  988.         lResult = func((int)wParam, (LPNMHDR)lParam, bHandled); \
  989.         if(bHandled) \
  990.             return TRUE; \
  991.     }
  992.  
  993. #define NOTIFY_ID_HANDLER(id, func) \
  994.     if(uMsg == WM_NOTIFY && id == ((LPNMHDR)lParam)->idFrom) \
  995.     { \
  996.         bHandled = TRUE; \
  997.         lResult = func((int)wParam, (LPNMHDR)lParam, bHandled); \
  998.         if(bHandled) \
  999.             return TRUE; \
  1000.     }
  1001.  
  1002. #define NOTIFY_CODE_HANDLER(cd, func) \
  1003.     if(uMsg == WM_NOTIFY && cd == ((LPNMHDR)lParam)->code) \
  1004.     { \
  1005.         bHandled = TRUE; \
  1006.         lResult = func((int)wParam, (LPNMHDR)lParam, bHandled); \
  1007.         if(bHandled) \
  1008.             return TRUE; \
  1009.     }
  1010.  
  1011. #define NOTIFY_RANGE_HANDLER(idFirst, idLast, func) \
  1012.     if(uMsg == WM_NOTIFY && ((LPNMHDR)lParam)->idFrom >= idFirst && ((LPNMHDR)lParam)->idFrom <= idLast) \
  1013.     { \
  1014.         bHandled = TRUE; \
  1015.         lResult = func((int)wParam, (LPNMHDR)lParam, bHandled); \
  1016.         if(bHandled) \
  1017.             return TRUE; \
  1018.     }
  1019.  
  1020. #define CHAIN_MSG_MAP(theChainClass) \
  1021.     { \
  1022.         if(theChainClass::ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult)) \
  1023.             return TRUE; \
  1024.     }
  1025.  
  1026. #define CHAIN_MSG_MAP_MEMBER(theChainMember) \
  1027.     { \
  1028.         if(theChainMember.ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult)) \
  1029.             return TRUE; \
  1030.     }
  1031.  
  1032. #define CHAIN_MSG_MAP_ALT(theChainClass, msgMapID) \
  1033.     { \
  1034.         if(theChainClass::ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, msgMapID)) \
  1035.             return TRUE; \
  1036.     }
  1037.  
  1038. #define CHAIN_MSG_MAP_ALT_MEMBER(theChainMember, msgMapID) \
  1039.     { \
  1040.         if(theChainMember.ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, msgMapID)) \
  1041.             return TRUE; \
  1042.     }
  1043.  
  1044. #define CHAIN_MSG_MAP_DYNAMIC(dynaChainID) \
  1045.     { \
  1046.         if(CDynamicChain::CallChain(dynaChainID, hWnd, uMsg, wParam, lParam, lResult)) \
  1047.             return TRUE; \
  1048.     }
  1049.  
  1050. #define CHAIN_MSG_MAP_ALT_DYNAMIC(dynaChainID, msgMapID) \
  1051.     { \
  1052.         if(CDynamicChain::CallChain(dynaChainID, hWnd, uMsg, wParam, lParam, lResult, msgMapID)) \
  1053.             return TRUE; \
  1054.     }
  1055.  
  1056. #define END_MSG_MAP() \
  1057.             break; \
  1058.         default: \
  1059.             ATLTRACE(_T("Invalid message map ID (%i)\n"), dwMsgMapID); \
  1060.             _ASSERTE(FALSE); \
  1061.             break; \
  1062.         } \
  1063.         return FALSE; \
  1064.     }
  1065.  
  1066.  
  1067. // Handler prototypes:
  1068. //  LRESULT MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
  1069. //  LRESULT CommandHandler(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
  1070. //  LRESULT NotifyHandler(int idCtrl, LPNMHDR pnmh, BOOL& bHandled);
  1071.  
  1072.  
  1073. /////////////////////////////////////////////////////////////////////////////
  1074. // CDynamicChain - provides support for dynamic chaining
  1075.  
  1076. class CDynamicChain
  1077. {
  1078. public:
  1079.     struct ATL_CHAIN_ENTRY
  1080.     {
  1081.         DWORD m_dwChainID;
  1082.         CMessageMap* m_pObject;
  1083.         DWORD m_dwMsgMapID;
  1084.     };
  1085.  
  1086.     int m_nEntries;
  1087.     ATL_CHAIN_ENTRY** m_pChainEntry;
  1088.  
  1089.     CDynamicChain() : m_nEntries(0), m_pChainEntry(NULL)
  1090.     { }
  1091.  
  1092.     ~CDynamicChain();
  1093.     BOOL SetChainEntry(DWORD dwChainID, CMessageMap* pObject, DWORD dwMsgMapID = 0);
  1094.     BOOL RemoveChainEntry(DWORD dwChainID);
  1095.     BOOL CallChain(DWORD dwChainID, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lResult);
  1096. };
  1097.  
  1098.  
  1099. /////////////////////////////////////////////////////////////////////////////
  1100. // CWndClassInfo - Manages Windows class information
  1101.  
  1102. class CWndClassInfo
  1103. {
  1104. public:
  1105.     WNDCLASSEX m_wc;
  1106.     LPCTSTR m_lpszOrigName;
  1107.     WNDPROC pWndProc;
  1108.     LPCTSTR m_lpszCursorID;
  1109.     BOOL m_bSystemCursor;
  1110.     ATOM m_atom;
  1111.     TCHAR m_szAutoName[13];
  1112.     ATOM Register(WNDPROC*);
  1113. };
  1114.  
  1115. #define DECLARE_WND_CLASS(WndClassName) \
  1116. static CWndClassInfo& GetWndClassInfo() \
  1117. { \
  1118.     static CWndClassInfo wc = \
  1119.     { \
  1120.         { sizeof(WNDCLASSEX), CS_HREDRAW|CS_VREDRAW, StartWindowProc, \
  1121.           0, 0, 0, 0, 0, (HBRUSH)(COLOR_WINDOW+1), 0, WndClassName, 0 }, \
  1122.         NULL, NULL, IDC_ARROW, TRUE, 0, _T("") \
  1123.     }; \
  1124.     return wc; \
  1125. }
  1126.  
  1127. #define DECLARE_WND_SUPERCLASS(WndClassName, OrigWndClassName) \
  1128. static CWndClassInfo& GetWndClassInfo() \
  1129. { \
  1130.     static CWndClassInfo wc = \
  1131.     { \
  1132.         { sizeof(WNDCLASSEX), NULL, StartWindowProc, \
  1133.           0, 0, 0, 0, 0, NULL, 0, WndClassName, 0 }, \
  1134.         OrigWndClassName, NULL, NULL, TRUE, 0, _T("") \
  1135.     }; \
  1136.     return wc; \
  1137. }
  1138.  
  1139. /////////////////////////////////////////////////////////////////////////////
  1140. // CWindowImpl - Implements a window
  1141.  
  1142. class ATL_NO_VTABLE CWindowImplBase : public CWindow, public CMessageMap
  1143. {
  1144. public:
  1145.     CWndProcThunk m_thunk;
  1146.     WNDPROC m_pfnSuperWindowProc;
  1147.  
  1148.     CWindowImplBase() : m_pfnSuperWindowProc(::DefWindowProc)
  1149.     {}
  1150.  
  1151.     static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  1152.     static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  1153.     HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName,
  1154.             DWORD dwStyle, DWORD dwExStyle, UINT nID, ATOM atom);
  1155.     BOOL SubclassWindow(HWND hWnd);
  1156.     HWND UnsubclassWindow();
  1157.  
  1158.     LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
  1159.     {
  1160. #ifdef STRICT
  1161.         return ::CallWindowProc(m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
  1162. #else
  1163.         return ::CallWindowProc((FARPROC)m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
  1164. #endif
  1165.     }
  1166. };
  1167.  
  1168. template <class T>
  1169. class ATL_NO_VTABLE CWindowImpl : public CWindowImplBase
  1170. {
  1171. public:
  1172.     DECLARE_WND_CLASS(NULL)
  1173.  
  1174.     HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName = NULL,
  1175.             DWORD dwStyle = WS_CHILD | WS_VISIBLE, DWORD dwExStyle = 0,
  1176.             UINT nID = 0)
  1177.     {
  1178.         ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
  1179.         return CWindowImplBase::Create(hWndParent, rcPos, szWindowName, dwStyle, dwExStyle,
  1180.             nID, atom);
  1181.     }
  1182. };
  1183.  
  1184. /////////////////////////////////////////////////////////////////////////////
  1185. // CDialog - Implements a dialog box
  1186.  
  1187. class ATL_NO_VTABLE CDialogImplBase : public CWindow, public CMessageMap
  1188. {
  1189. public:
  1190.     CWndProcThunk m_thunk;
  1191.  
  1192.     static LRESULT CALLBACK StartDialogProc(HWND hWnd, UINT uMsg,
  1193.         WPARAM wParam, LPARAM lParam);
  1194.     static LRESULT CALLBACK DialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  1195.     BOOL EndDialog(int nRetCode);
  1196. };
  1197.  
  1198. template <class T>
  1199. class ATL_NO_VTABLE CDialogImpl : public CDialogImplBase
  1200. {
  1201. public:
  1202.     int DoModal(HWND hWndParent = ::GetActiveWindow())
  1203.     {
  1204.         _ASSERTE(m_hWnd == NULL);
  1205.         _Module.AddCreateWndData(&m_thunk.cd, (CDialogImplBase*)this);
  1206.         int nRet = ::DialogBoxParam(_Module.GetResourceInstance(),
  1207.                 MAKEINTRESOURCE(T::IDD),
  1208.                 hWndParent,
  1209.                 (DLGPROC)T::StartDialogProc,
  1210.                 NULL);
  1211.         m_hWnd = NULL;
  1212.         return nRet;
  1213.     }
  1214.  
  1215.     HWND Create(HWND hWndParent)
  1216.     {
  1217.         _ASSERTE(m_hWnd == NULL);
  1218.         _Module.AddCreateWndData(&m_thunk.cd, (CDialogImplBase*)this);
  1219.         HWND hWnd = ::CreateDialogParam(_Module.GetResourceInstance(),
  1220.                 MAKEINTRESOURCE(T::IDD),
  1221.                 hWndParent,
  1222.                 (DLGPROC)T::StartDialogProc,
  1223.                 NULL);
  1224.         _ASSERTE(m_hWnd == hWnd);
  1225.         return hWnd;
  1226.     }
  1227. };
  1228.  
  1229. /////////////////////////////////////////////////////////////////////////////
  1230. // CContainedWindow - Implements a contained window
  1231.  
  1232. class CContainedWindow : public CWindow
  1233. {
  1234. public:
  1235.     CWndProcThunk m_thunk;
  1236.     LPTSTR m_lpszClassName;
  1237.     WNDPROC m_pfnSuperWindowProc;
  1238.     CMessageMap* m_pObject;
  1239.     DWORD m_dwMsgMapID;
  1240.  
  1241.     CContainedWindow(LPTSTR lpszClassName, CMessageMap* pObject, DWORD dwMsgMapID = 0)
  1242.         : m_lpszClassName(lpszClassName),
  1243.         m_pfnSuperWindowProc(::DefWindowProc),
  1244.         m_pObject(pObject), m_dwMsgMapID(dwMsgMapID)
  1245.     { }
  1246.  
  1247.     void SwitchMessageMap(DWORD dwMsgMapID)
  1248.     {
  1249.         m_dwMsgMapID = dwMsgMapID;
  1250.     }
  1251.  
  1252.     static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg,
  1253.         WPARAM wParam, LPARAM lParam);
  1254.     static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  1255.     ATOM RegisterWndSuperclass();
  1256.     HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName = NULL,
  1257.         DWORD dwStyle = WS_CHILD | WS_VISIBLE, DWORD dwExStyle = 0,
  1258.         UINT nID = 0);
  1259.     BOOL SubclassWindow(HWND hWnd);
  1260.     HWND UnsubclassWindow();
  1261.  
  1262.     LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
  1263.     {
  1264. #ifdef STRICT
  1265.         return ::CallWindowProc(m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
  1266. #else
  1267.         return ::CallWindowProc((FARPROC)m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
  1268. #endif
  1269.     }
  1270. };
  1271.  
  1272.  
  1273. #ifndef ATL_NO_NAMESPACE
  1274. }; //namespace ATL
  1275. #endif
  1276.  
  1277. #endif // __ATLWIN_H__
  1278.